# Method 1: append()
my_list = [1, 2, 3]
my_list.append(4)
print("Method 1 - append:", my_list)

# Method 2: extend()
my_list.extend([5, 6])
print("Method 2 - extend:", my_list)

# Method 3: remove()
my_list.remove(3)
print("Method 3 - remove:", my_list)

# Example 1: Doubling each element in a list using map
numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x * 2, numbers))
print("Doubled Numbers:", doubled_numbers)

# Example 2: Converting strings to uppercase using map
words = ["apple", "banana", "cherry"]
uppercase_words = list(map(str.upper, words))
print("Uppercase Words:", uppercase_words)

# Example 1: Filtering even numbers from a list
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print("Even Numbers:", even_numbers)

# Example 2: Filtering words with length greater than 5
words = ["apple", "banana", "cherry", "date", "elderberry"]
long_words = list(filter(lambda word: len(word) > 5, words))
print("Long Words:", long_words)

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [num for num in numbers if num % 2 == 0]
print("Even Numbers:", even_numbers)

numbers = [1, 5, 8, 3, 12, 6, 10, 7]
even_numbers = [num for num in numbers if num % 2 == 0]
largest_even = max(even_numbers)
print("Largest Even Number:", largest_even)

numbers = [1, 5, 8, 3, 12, 6, 10, 7]
odd_numbers = [num for num in numbers if num % 2 != 0]
largest_odd = max(odd_numbers)
print("Largest Odd Number:", largest_odd)

my_list = [1, 2, 3, 4, 5]
my_list[0], my_list[-1] = my_list[-1], my_list[0]
print("Swapped List:", my_list)

numbers = [1, 2, 3, 4, 5]
sum_of_elements = sum(numbers)
print("Sum of Elements:", sum_of_elements)

def sum_of_list(numbers):
    return sum(numbers)

numbers = [1, 2, 3, 4, 5]
result = sum_of_list(numbers)
print("Sum of Elements (Function):", result)

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print("Reversed List:", reversed_list)

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = {**dict1, **dict2}
print("Merged Dictionary:", merged_dict)

numbers = [1, -2, 3, -4, 5, -6]
sum_positive = lambda x: sum(num for num in x if num > 0)
sum_negative = lambda x: sum(num for num in x if num < 0)

print("Sum of Positive Numbers:", sum_positive(numbers))
print("Sum of Negative Numbers:", sum_negative(numbers))

numbers = [1, -2, 3, -4, 5, -6]
arrange_numbers = lambda x: sorted(x, key=lambda num: (num >= 0, num))

arranged_numbers = arrange_numbers(numbers)
print("Rearranged Numbers:", arranged_numbers)

numbers = [19, 26, 39, 52, 65, 13, 78]
divisible_by_nineteen_or_thirteen = lambda x: [num for num in x if num % 19 == 0 or num % 13 == 0]

result = divisible_by_nineteen_or_thirteen(numbers)
print("Numbers Divisible by Nineteen or Thirteen:", result)

def linear_search(lst, target):
    for i, num in enumerate(lst):
        if num == target:
            return i
    return None

# Example usage
user_input = input("Enter the list of numbers separated by spaces: ")
numbers = list(map(int, user_input.split()))

target_number = int(input("The number to search for: "))

result = linear_search(numbers, target_number)

if result is not None:
    print(f"{target_number} was found at index {result}.")
else:
    print(f"{target_number} was not found in the list.")

def group_elements(lst):
    grouped_dict = {}

    for elem in lst:
        if elem in grouped_dict:
            grouped_dict[elem].append(elem)
        else:
            grouped_dict[elem] = [elem]

    # Sort the dictionary by frequency in descending order
    sorted_list = sorted(grouped_dict.items(), key=lambda x: len(x[1]), reverse=True)

    # Convert the sorted list back to a dictionary
    sorted_dict = dict(sorted_list)

    return sorted_dict

# Example usage
test_list = [4, 6, 6, 4, 2, 2, 4, 8, 5, 8]
result_dict = group_elements(test_list)

print("Input List:", test_list)
print("Output Dictionary:", result_dict)

## def rotate_matrix_90_degrees(matrix):
    N = len(matrix)

    # Transpose the matrix
    for i in range(N):
        for j in range(i, N):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

    # Reverse each row
    for i in range(N):
        matrix[i].reverse()

# Get the size of the matrix from the user
N = int(input("Enter the size of the matrix (N): "))

# Get the matrix input from the user
matrix = []
print("Enter the matrix (each row on a new line):")
for _ in range(N):
    row = list(map(int, input().split()))
    matrix.append(row)

# Rotate the matrix by 90 degrees clockwise
rotate_matrix_90_degrees(matrix)

# Print the rotated matrix
print("Rotated Matrix:")
for row in matrix:
    print(" ".join(map(str, row)))

def longest_common_prefix(str_list):
    if not str_list:
        return -1

    str_list.sort()

    prefix = ""
    for i in range(len(str_list[0])):
        char = str_list[0][i]
        prefix_match = True

        for s in str_list:
            if not s.startswith(prefix + char):
                prefix_match = False
                break

        if prefix_match:
            prefix += char
        else:
            break

    return prefix if prefix else -1

# Example usage
input_list1 = ["lessonplan", "lesson", "lees", "length"]
result1 = longest_common_prefix(input_list1)
print("Input list:", input_list1)
print("The longest Common Prefix is:", result1)

input_list2 = ["python", "pythonprogramming", "pythonlist"]
result2 = longest_common_prefix(input_list2)
print("\nInput list:", input_list2)
print("The longest Common Prefix is:", result2)

input_list3 = ["lessonplan", "lesson", "ees", "length"]
result3 = longest_common_prefix(input_list3)
print("\nInput list:", input_list3)
print("The longest Common Prefix is:", result3)

def encrypt_rail_fence(message, num_rails=3):
    rails = ['' for _ in range(num_rails)]

    for i, char in enumerate(message):
        rail_index = i % num_rails
        rails[rail_index] += char

    encrypted_message = ''
    for rail in rails:
        encrypted_message += rail

    return encrypted_message

# Example usage:
user_input = input("Enter the string to encrypt: ")
encrypted_message = encrypt_rail_fence(user_input, 5)
print("Encrypted message:", encrypted_message)

def decrypt_rail_fence(encrypted_message, num_rails=3):
    rail_length = len(encrypted_message) // num_rails
    rails = ['' for _ in range(num_rails)]

    # Distribute characters to the rails
    for i in range(num_rails):
        if i < len(encrypted_message) % num_rails:
            rails[i] = encrypted_message[i * (rail_length + 1):(i + 1) * (rail_length + 1)]
        else:
            rails[i] = encrypted_message[i * rail_length + len(encrypted_message) % num_rails:
                                            (i + 1) * rail_length + len(encrypted_message) % num_rails]

    # Reconstruct the original message
    decrypted_message = ''
    for i in range(rail_length + 1):
        for j in range(num_rails):
            if i < len(rails[j]):
                decrypted_message += rails[j][i]

    return decrypted_message

# Example usage:
encrypted_input = input("Enter the string to decrypt: ")
decrypted_message = decrypt_rail_fence(encrypted_input, 5)
print("Decrypted message:", decrypted_message)

def create_word_dict(decrypted_message):
    # Split the decrypted message into words
    words = decrypted_message.split()

    # Create a dictionary with the first character of each word as the key
    word_dict = {}
    for word in words:
        first_char = word[0].lower()  # Convert to lowercase for case-insensitivity
        if first_char in word_dict:
            word_dict[first_char].append(word)
        else:
            word_dict[first_char] = [word]

    # Sort the dictionary based on the number of elements in each list in descending order
    sorted_word_dict = dict(sorted(word_dict.items(), key=lambda x: len(x[1]), reverse=True))

    return sorted_word_dict

# Example usage:
decrypted_input = input("Enter Decrypted Message: ")
word_dict = create_word_dict(decrypted_input)

print("Output:", word_dict)

# Function to print all possible combinations
def print_all_combinations(current, remaining):
    if not remaining:
        print(current)
        return
    seen = set()
    for i in range(len(remaining)):
        if remaining[i] not in seen:
            seen.add(remaining[i])
            print_all_combinations(current + [remaining[i]], remaining[:i] + remaining[i+1:])

# Function to count unique values inside a list
def count_unique_items(lst):
    unique_items = set()
    for item in lst:
        unique_items.add(item)
    print("No of unique items are:", len(unique_items))

# Function to find the product of list excluding duplicates
def product_excluding_duplicates(lst):
    unique_items = set(lst)
    product = 1
    for item in unique_items:
        product *= item
    return product

# Function to find the sum of list's elements excluding duplicates
def sum_excluding_duplicates(lst):
    unique_items = set(lst)
    return sum(unique_items)

# Example usage:
digits_input = [1, 2, 3]
print("All possible combinations:")
print_all_combinations([], digits_input)

list_input = [1, 2, 3]
count_unique_items(list_input)

list_input = [1, 2, 2]
count_unique_items(list_input)

list_input = [2, 2, 3]
count_unique_items(list_input)

print("Product excluding duplicates:", product_excluding_duplicates(list_input))
print("Sum excluding duplicates:", sum_excluding_duplicates(list_input))


print_all_combinations([],[2,2,2])

from functools import reduce

# PART - A
def convert_to_tuple(input_list):
    """
    Convert the given list into a tuple of strings using map function.

    Parameters:
    input_list (list): The input list to be converted.

    Returns:
    tuple: The tuple of strings.
    """
    return tuple(map(str, input_list))

# PART - B
multiply_by_10 = lambda x: x * 10

def multiply_list_by_10(input_list):
    """
    Multiply each number of the given list with 10 using lambda function.

    Parameters:
    input_list (list): The input list to be multiplied.

    Returns:
    list: The list with elements multiplied by 10.
    """
    return list(map(multiply_by_10, input_list))

# PART - C
def multiply_all_elements(input_list):
    """
    Multiply all elements of the given list using reduce function and return the product.

    Parameters:
    input_list (list): The input list to calculate the product.

    Returns:
    int: The product of all elements.
    """
    return reduce(lambda x, y: x * y, input_list, 1)

# Example Test Case
input_list = [1, 2, 3, 4]

# PART - A
output_tuple = convert_to_tuple(input_list)
print("PART - A")
print(f"Input: {input_list}")
print(f"Output: {output_tuple}\n")

# PART - B
output_multiply_by_10 = multiply_list_by_10(input_list)
print("PART - B")
print(f"Input: {input_list}")
print(f"Output: {output_multiply_by_10}\n")

# PART - C
output_multiply_all_elements = multiply_all_elements(input_list)
print("PART - C")
print(f"Input: {input_list}")
print(f"Output: {output_multiply_all_elements}")

# PART - D
def countchar(input_string, char_to_count):
    """
    Count the occurrence of a character in a given string without using inbuilt functions.

    Parameters:
    input_string (str): The input string.
    char_to_count (str): The character to count in the input string.

    Returns:
    int: The count of the character in the input string.
    """
    count = 0
    for char in input_string:
        if char == char_to_count:
            count += 1
    return count

def findchar(input_string, char_to_find):
    """
    Find the index of the first occurrence of a character in a given string without using inbuilt functions.

    Parameters:
    input_string (str): The input string.
    char_to_find (str): The character to find in the input string.

    Returns:
    int: The index of the first occurrence of the character, or -1 if not found.
    """
    index = 0
    for char in input_string:
        if char == char_to_find:
            return index
        index += 1
    return -1

# Example Test Cases
input_string1 = 'hello'
char_count = 'l'
output_count = countchar(input_string1, char_count)
print(f"Input string: '{input_string1}'")
print(f"countchar('{char_count}'): {output_count}\n")

input_string2 = 'helloe'
char_to_find1 = 'e'
char_to_find2 = 'z'
output_find1 = findchar(input_string2, char_to_find1)
output_find2 = findchar(input_string2, char_to_find2)
print(f"Input string: '{input_string2}'")
print(f"findchar('{char_to_find1}'): {output_find1}")
print(f"findchar('{char_to_find2}'): {output_find2}")

# Given list of numbers
m = [2, 4, -6, -9, 11, -12, 14, -5, 17]

# Lambda function to filter positive numbers
positive_numbers = lambda x: x > 0

# Lambda function to filter negative numbers
negative_numbers = lambda x: x < 0

# Calculate the sum of positive numbers using lambda function
sum_positive = sum(filter(positive_numbers, m))

# Calculate the sum of negative numbers using lambda function
sum_negative = sum(filter(negative_numbers, m))

# Output the results
print(f"Input: {m}")
print(f"Sum of the positive numbers: {sum_positive}")
print(f"Sum of the negative numbers: {sum_negative}")

# User input for the password
password = input("Enter a password: ")

# Check condition 1: Password length should be at least 8 characters
if len(password) < 8:
    print("Invalid Password: Password should be at least 8 characters long.")
else:
    # Check condition 2: Password should contain at least one uppercase and one lowercase character
    has_uppercase = False
    has_lowercase = False
    for char in password:
        if char.isupper():
            has_uppercase = True
        elif char.islower():
            has_lowercase = True

    # Check condition 3: Password must have at least one number
    has_digit = False
    for char in password:
        if char.isdigit():
            has_digit = True

    # Validate the password based on all conditions
    if has_uppercase and has_lowercase and has_digit:
        print("Valid Password")
    else:
        print("Invalid Password: Password should contain at least one uppercase and one lowercase character, and one number.")

def count_word_frequency(paragraph):
    """
    Count the frequency of words in a paragraph and store in a dictionary.

    Parameters:
    paragraph (str): The input paragraph.

    Returns:
    dict: A dictionary with words as keys and their frequencies as values.
    """
    word_frequency = {}
    words = paragraph.split()

    for word in words:
        # Remove punctuation (assuming simple cases with only letters)
        word = word.strip('.,!?')

        # Convert word to lowercase for case-insensitive counting
        word = word.lower()

        # Update the dictionary with word frequencies
        word_frequency[word] = word_frequency.get(word, 0) + 1

    return word_frequency

# Example usage
input_paragraph = "Dog the quick brown fox jumps over the lazy dog"
output_dict = count_word_frequency(input_paragraph)

# Output the result
print(f"Input paragraph: '{input_paragraph}'")
print("Output:", output_dict)

def is_valid_password(password):
    """
    Check if the entered password is correct and convert digits to English words.

    Parameters:
    password (str): The input password.

    Returns:
    tuple: A tuple containing a boolean indicating whether the password is valid and the converted digits.
    """
    # Check conditions for a valid password
    has_upper = False
    has_lower = False
    digit_count = 0
    has_special = False

    for char in password:
        if char.isupper():
            has_upper = True
        elif char.islower():
            has_lower = True
        elif char.isdigit():
            digit_count += 1
        elif char in "!@#$%^&*()-_=+[]{}|;:'\",.<>/?`~":
            has_special = True

    if (
        has_upper
        and has_lower
        and 1 <= digit_count <= 3
        and has_special
        and 8 <= len(password) <= 15
    ):
        # Extract digits from the password
        digits = ''
        for char in password:
            if char.isdigit():
                digits += char

        # Convert digits to English words
        num_in_words = convert_to_words(int(digits))

        return True, digits, num_in_words
    else:
        return False, None, None

def convert_to_words(num):
    """
    Convert a number to its English word representation.

    Parameters:
    num (int): The input number.

    Returns:
    str: The English word representation of the number.
    """
    # Define lists for unit and tens places
    units = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
    teens = ["", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
    tens = ["", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

    # Convert each digit place to English words
    def convert_below_hundred(n):
        if n < 10:
            return units[n]
        elif 10 < n < 20:
            return teens[n - 10]
        else:
            return tens[n // 10] + ' ' + units[n % 10]

    if num == 0:
        return "zero"

    # Convert each group of three digits to English words
    result = ''
    if num >= 100:
        result += units[num // 100] + ' hundred '

    result += convert_below_hundred(num % 100)

    return result.strip()

# Example usage
password1 = "R@m@3fa1tu9e$"
valid1, digits1, num_in_words1 = is_valid_password(password1)
print(f"case 1\npw= {password1}")
if valid1:
    print("Valid Password")
    print(f"num= {digits1}")
    print(f"{num_in_words1}")
else:
    print("Invalid Password")

password2 = "S@m@6a1tue$"
valid2, digits2, num_in_words2 = is_valid_password(password2)
print(f"\ncase 2\npw= {password2}")
if valid2:
    print("Valid Password")
    print(f"num= {digits2}")
    print(f"{num_in_words2}")
else:
    print("Invalid Password")

password3 = "S@m@6a26u8$"
valid3, _, _ = is_valid_password(password3)
print(f"\ncase 3\npw= {password3}")
if valid3:
    print("Valid Password")
else:
    print("Invalid Password")

def count_strings_with_same_ends(strings):
    """
    Count the number of strings with length 3 or more, and the first and last character are the same.

    Parameters:
    strings (list): List of strings.

    Returns:
    int: Number of strings meeting the specified conditions.
    """
    count = 0

    for string in strings:
        if len(string) >= 3 and string[0] == string[-1]:
            count += 1

    return count

# Example usage
input_strings = ['abc', 'xyz', 'aba', '2112', '123451', '12345']
result = count_strings_with_same_ends(input_strings)

# Output the result
print(f"Input strings: {input_strings}")
print(f"Number of strings with the same first and last character: {result}")

def is_balanced(lst):
    # Function to check if a list is balanced
    return sum(lst[::2]) == sum(lst[1::2])

def count_special_elements(lst):
    # Function to count special elements and print updated lists
    count = 0
    for i in range(len(lst)):
        temp_lst = lst.copy()
        removed_element = temp_lst.pop(i)
        if is_balanced(temp_lst):
            count += 1
            print(f"Original List: {lst}")
            print(f"Index to be removed is: {i}")
            print(f"List after removing index {i} : {temp_lst}")
            print()

    return count

# Example usage
list1 = [5, 5, 2, 5, 8]
list2 = [2, 1, 6, 4]

count_special1 = count_special_elements(list1)
print(f"Total number of special elements: {count_special1}")
print()

count_special2 = count_special_elements(list2)
print(f"Total number of special elements: {count_special2}")

def create_dictionary(sentence):
    words = sentence.split()
    result_dict = {}

    for word in words:
        # Use the first character of the word as the key
        key = word[0]

        # Check if the key is already present in the dictionary
        if key in result_dict:
            result_dict[key].append(word)
        else:
            result_dict[key] = [word]

    return result_dict

# Example usage
input_sentence = "Don’t wait for your feelings to change to take the action. Take the action and your feelings will change"
output_dict = create_dictionary(input_sentence)

# Output the result
print("Input:", input_sentence)
print("Output:", output_dict)

def is_valid_password(password):
    # Function to check if the new password format is correct
    # Conditions: 1 number, 1 upper letter, 1 lower letter, 1 special character, length between 8 and 15
    has_digit = False
    has_lower = False
    has_upper = False
    has_special = False
    is_length_valid = 8 <= len(password) <= 15

    for char in password:
        if char.isdigit():
            has_digit = True
        elif char.islower():
            has_lower = True
        elif char.isupper():
            has_upper = True
        elif char in '@$_':
            has_special = True

    return has_digit and has_lower and has_upper and has_special and is_length_valid

def update_password(username, old_password, new_password):
    # Function to update the password for a given username
    if username in d and d[username] == old_password and is_valid_password(new_password):
        d[username] = new_password
        print("Password updated successfully.")
        return True
    else:
        print("Invalid username or old password.")
        return False

# Given dictionary
d = {"student0": 'Student@0', "student1": 'Student@11', "student2": 'Student@121', "student3": 'Student@052',
     "student4": 'Student@01278', "student5": 'Student@0125', "student6": 'Student@042', "student7": 'Student@07800',
     "student8": 'Student@012', "student9": 'Student@04789'}

# Input: User and Password Verification
username_attempts = 0
while username_attempts < 3:
    username_input = input("Enter username: ")
    password_input = input("Enter password: ")

    if username_input in d and d[username_input] == password_input:
        break
    else:
        print("Enter correct username and password.")
        username_attempts += 1

if username_attempts == 3:
    print("Try after 24h.")
else:
    # Input: New Password Verification
    password_attempts = 0
    while password_attempts < 3:
        new_password_input = input("Enter new password: ")

        if is_valid_password(new_password_input):
            if update_password(username_input, password_input, new_password_input):
                break
        else:
            print("Follow the password format.")
            password_attempts += 1

    if password_attempts == 3:
        print("Follow the password format. Try after 24h.")
        d = old_d  # Revert to the old dictionary

# Print the updated dictionary
print("Updated Dictionary:", d)

# Print username and password according to ascending order of password length
sorted_credentials = sorted(d.items(), key=lambda x: len(x[1]))
print("Username and Passwords in Ascending Order of Password Length:")
for username, password in sorted_credentials:
    print(f"Username: {username}, Password: {password}")